package com.yehongyu.mytools.basic.util.string;

/**
 * <p>
 * Title: OSSDevelop
 * </p>
 * <p>
 * Description: 产品配置
 * </p>
 * <p>
 * Copyright: Copyright (c) 2004
 * </p>
 * <p>
 * Company: Sinosoft
 * </p>
 * 
 * @author Stephen
 * @version 1.0
 */
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.sql.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class UniversalFun {
    public static final BigDecimal ONE_HUNDRED = new BigDecimal("100.0");

    /**
     * 货币数据的小数位数
     */
    public static final int MONEY_SCALE = 2;

    /**
     * 时间类型数据对应的转换为字符串时的格式
     */
    private static String pattern = "yyyy-MM-dd HH:mm:ss";

    /**
     * 生成带时分秒格式的时间数据转换对象
     */
    private static SimpleDateFormat sdf = new SimpleDateFormat(pattern);

    /**
     * 不带时间的日期类型数据对应的格式
     */
    private static final String noTimePattern = "yyyy-MM-dd";

    /**
     * 用于转换没有时间的日期类型数据的转换对象
     */
    private static SimpleDateFormat ntsdf = new SimpleDateFormat(noTimePattern);

    private static Log log = LogFactory.getLog(UniversalFun.class);

    /**
     * 检测字符串是否表示确认信息的函数， 即字符串是否为true, yes, on, y, 1中的任何形式之一。
     * 
     * @param param
     *            要判断的字符串
     * @return 如果是则返回true，否则返回false.
     */
    public static boolean isAffirm(String param) {
        if (param == null) {
            return false;
        }
        return (param.equalsIgnoreCase("true") || param.equalsIgnoreCase("yes")
                || param.equalsIgnoreCase("on") || param.equalsIgnoreCase("y") || param
                .equalsIgnoreCase("1"));
    }

    /**
     * 判断字符串是否可以转换为java.sql.Date类型数据。
     * 
     * @param strDate
     *            要判断的字符串
     * @param bRequired
     *            是否不能为空
     * @return 如果符合时间格式或者可以为空并且字符串为空返回true，否则false
     */
    public static boolean validateSqlDate(String strDate, boolean bRequired) {
        if (strDate == null || strDate.trim().length() == 0) {
            return (!bRequired);
        }
        strDate = strDate.trim();
        Date date = null;
        try {
            if (strDate.length() > 10) {
                // 转换有时分秒的时间类型数据
                java.util.Date ud = sdf.parse(strDate);
                date = new Date(ud.getTime());
                System.out.println(date);
                return true;
            } else {
                // 转换没有时分秒的时间类型数据
                date = Date.valueOf(strDate);
                System.out.println(date);
                return true;
            }
        } catch (ParseException ex) {
            return false;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断字符串是否可以转换为BigDecimal类型的数据
     * 
     * @param strDecimal
     *            要转换的字符串
     * @param bRequired
     *            该字段是否不能为空
     * @return 返回的结果,true表示可以转换为BigDecimal类型的数据,否则false
     */
    public static boolean validateBigDecimal(String strDecimal,
            boolean bRequired) {
        if (strDecimal == null || strDecimal.trim().length() == 0) {
            return (!bRequired);
        }
        try {
            BigDecimal tempDecimal = new BigDecimal(strDecimal);
            System.out.println(tempDecimal);
            return true;
        } catch (Exception ex) {
            System.err.println("BigDecimal format error");
            return false;
        }
    }

    public static BigDecimal parseBigDecimal(String strDecimal) {
        return (validateBigDecimal(strDecimal, true) ? new BigDecimal(
                strDecimal) : null);
    }

    /**
     * 返回字符串表示的时间，如果不能转换为时间类型数据则返回nll
     * 
     * @param strDate
     *            需要进行转换的字符串
     * @return 转换后的时间
     */
    public static Date parseDate(String strDate) {
        if (strDate == null) {
            return null;
        }
        strDate = strDate.trim();
        Date date = null;
        try {
            if (strDate.length() > 10) {
                // 转换有时分秒的时间类型数据
                java.util.Date ud = sdf.parse(strDate);
                date = new Date(ud.getTime());
            } else {
                // 转换没有时分秒的时间类型数据
                date = Date.valueOf(strDate);
            }
        } catch (ParseException ex) {
            date = null;
        } catch (Exception e) {
            date = null;
        }
        return date;
    }

    /**
     * 判断字符串是否为空或者长度为0
     * 
     * @param strForCheck
     *            需要判断的字符串
     * @return 如果字符串为空或者长度为0则返回true，否则返回false。
     */
    public static boolean isEmptyString(String strForCheck) {
        return (strForCheck == null || strForCheck.trim().length() == 0);
    }

    /**
     * 将字符串转换为Integer类型的数据，如果转换失败，返回null
     * 
     * @param strInt
     *            需要转换的字符串
     * @return 转换后的数据
     */
    public static Integer parseInt(String strInt) {
        System.out.println("parse int:" + strInt);
        if (isEmptyString(strInt)) {
            return null;
        }
        int intValue = getInt(strInt);
        return new Integer(intValue);
        //if (!isEmptyString(strInt)) {
        //    try {
        //        Integer ivalue = Integer.valueOf(strInt);
        //        return ivalue;
        //    } catch (NumberFormatException ex) {
        //    }
        //}
        //return null;
    }

    /**
     * 将字符串转换为Integer类型的数据，如果转换失败，返回null
     * 
     * @param strInt
     *            需要转换的字符串
     * @param defaultValue
     *            如果不能转换返回的默认值
     * @return 转换结果
     */
    public static Integer parseInt(String strInt, int defaultValue) {
        Integer ivalue = parseInt(strInt);
        return (ivalue == null) ? new Integer(defaultValue) : ivalue;
    }

    /**
     * 将long类型的String转换为Long类型的数据
     * 
     * @param strLong
     *            要转换的String
     * @return 返回的Long类型数据
     */
    public static Long parseLong(String strLong) {
        if (!isEmptyString(strLong)) {
            long longValue = getLong(strLong);
            return new Long(longValue);
            //try {
            //    Long ivalue = Long.valueOf(strLong);
            //    return ivalue;
            //} catch (NumberFormatException ex) {
            //}
        }
        return null;
    }

    /**
     * 根据字符串获取对应的Double对象
     * 
     * @param strDouble
     *            double字符串
     * @return 获取的Double类型的数据
     */
    public static Double parseDouble(String strDouble) {
        if (isEmptyString(strDouble)) {
            return null;
        }
        return Double.valueOf(strDouble);
    }

    /**
     * 根据字符串获取对应的Short对象
     * 
     * @param strShort
     *            Short类型的字符串
     * @return 生成的Short类型的对象
     */
    public static Short parseShort(String strShort) {
        if (isEmptyString(strShort)) {
            return null;
        }
        short shortValue = getShort(strShort);
        return new Short(shortValue);
    }

    public static BigDecimal getFormMoneyValue(BigDecimal money) {
        BigDecimal tmpDecimal = null;
        if (money != null) {
            tmpDecimal = money.divide(ONE_HUNDRED, MONEY_SCALE,
                    BigDecimal.ROUND_HALF_UP);
        }
        return tmpDecimal;
    }

    public static BigDecimal getDtoMoneyValue(BigDecimal money) {
        BigDecimal tmpDecimal = null;
        if (money != null) {
            tmpDecimal = money.multiply(ONE_HUNDRED);
        }
        return tmpDecimal;
    }

    /**
     * 获得Date类型的数据的字符串结果 带时分秒的数据
     * 
     * @param date
     *            要进行转换的Date类型的数据
     * @return 返回的String类型数据, 如果转换失败, 返回null
     */
    public static String getDateString(java.util.Date date) {
        if (date == null) {
            return null;
        }
        try {
            return sdf.format(date);
        } catch (Exception ex) {
            return null;
        }
    }

    /**
     * 获取Object对象的int值
     * 
     * @param valueObj
     *            保存数据的Obejct对象
     * @return 对象中保存的int值
     */
    public static int getInt(Object valueObj)  {
        if (valueObj == null) {
            return 0;
        }
        try {
            Double doubleValue = Double.valueOf(valueObj.toString());
            int returnValue = doubleValue.intValue();
            return returnValue;
        } catch (NumberFormatException e) {
            log.debug("The data format error occurred!");
            log.debug(e.getMessage());
        }
        return 0;
    }

    /**
     * 获取Object对象中的值的BigDecimal值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象 的值对应的BigDecimal对象
     */
    public static BigDecimal getBigDecimal(Object valueObj)
             {
        if (valueObj == null) {
            return null;
        }
        try {
            BigDecimal tmpObj = new BigDecimal(valueObj.toString());
            return tmpObj;
        } catch (NumberFormatException nfe) {
            log.debug(nfe.getMessage());
            log.debug("return null instead");
        }
        return null;
    }

    /**
     * 获取Object对象中保存的数据的float值
     * 
     * @param valueObj
     *            保存数据的object对象
     * @return Object对象中保存的数据的float值
     */
    public static float getFloat(Object valueObj)  {
        if (valueObj == null) {
            return 0.0f;
        }
        try {
            Double doubleValue = Double.valueOf(valueObj.toString());
            float returnValue = doubleValue.floatValue();
            return returnValue;
        } catch (NumberFormatException e) {
            log.debug("The data format error occurred!");
            log.debug(e.getMessage());
        }
        return 0.0f;
    }

    /**
     * 获取Object对象中保存的数据的double值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的double值
     */
    public static double getDouble(Object valueObj)  {
        if (valueObj == null) {
            return 0.0;
        }
        try {
            Double doubleValue = Double.valueOf(valueObj.toString());
            double returnValue = doubleValue.doubleValue();
            return returnValue;
        } catch (NumberFormatException e) {
            log.debug("The data format error occurred!");
            log.debug(e.getMessage());
        }
        return 0.0;
    }

    /**
     * 获取Object对象中保存的数据的short类型值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的数据的short值
     */
    public static short getShort(Object valueObj)  {
        if (valueObj == null) {
            return 0;
        }
        try {
            Double doubleValue = Double.valueOf(valueObj.toString());
            short returnValue = doubleValue.shortValue();
            return returnValue;
        } catch (NumberFormatException e) {
            log.debug("The data format error occurred!");
            log.debug(e.getMessage());
        }
        return 0;
    }

    /**
     * 获取Object对象中保存的数据的long类型值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的数据的long类型的值
     */
    public static long getLong(Object valueObj)  {
        if (valueObj == null) {
            return 0L;
        }
        try {
            Double doubleValue = Double.valueOf(valueObj.toString());
            long returnValue = doubleValue.longValue();
            return returnValue;
        } catch (NumberFormatException e) {
            log.debug("The data format error occurred!");
            log.debug(e.getMessage());
        }
        return 0L;
    }

    /**
     * 如果指定的对象为字符串，则将字符串从指定的srcCharSet转换到destCharSet
     * 
     * @param valueObj
     *            要进行转换的Object对象
     * @param srcCharSet
     *            源字符集
     * @param destCharSet
     *            目标字符集
     * @return 转换后的对象
     */
    public static Object getObject(Object valueObj, String srcCharSet,
            String destCharSet) {
        if (valueObj != null && srcCharSet != null && destCharSet != null
                && valueObj instanceof String) {
            String strValue = (String) valueObj;
            try {
                strValue = new String(strValue.getBytes(srcCharSet),
                        destCharSet);
                return strValue;
            } catch (UnsupportedEncodingException e) {
                log.error("Error on change charset from GBK to ISO8859_1"
                        + e.getMessage(), e);
            }
        }
        return valueObj;
    }

    /**
     * 获取Object对象中保存的数据的String类型值
     * 
     * @param valueObj
     *            保存数据的Ojbect对象
     * @return Object对象中保存的数据的String值
     */
    public static String getString(Object valueObj)  {
        if (valueObj == null) {
            return null;
        }
        return valueObj.toString();
    }

    /**
     * 获取Object对象中保存的数据的Timestamp对象的值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的数据的Timestamp值
     */
    public static Timestamp getTimestamp(Object valueObj)
             {
        if (valueObj == null) {
            return null;
        }
        if (valueObj instanceof java.util.Date) {
            long time = ((java.util.Date) valueObj).getTime();
            return new Timestamp(time);
        }
        try {
            Timestamp tmpDate = Timestamp.valueOf(valueObj.toString());
            return tmpDate;
        } catch (IllegalArgumentException iae) {
            log.debug("Error on convert " + valueObj + " to Timestamp");
            log.debug(iae.toString());
        }
        return null;
    }

    /**
     * 获取Object对象中保存的数据的Time对象的值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的数据的Time类型值
     */
    public static Time getTime(Object valueObj)  {
        if (valueObj == null) {
            return null;
        }
        if (valueObj instanceof java.util.Date) {
            long time = ((java.util.Date) valueObj).getTime();
            return new Time(time);
        }
        try {
            Time tmpDate = Time.valueOf(valueObj.toString());
            return tmpDate;
        } catch (IllegalArgumentException iae) {
            log.debug("Error on convert " + valueObj + " to Time");
            log.debug(iae.toString());
        }
        return null;
    }

    /**
     * 获取Object对象中保存的数据的Date类型的值
     * 
     * @param valueObj
     *            保存数据的Object对象
     * @return Object对象中保存的Date类型的值
     */
    public static java.sql.Date getDate(Object valueObj)
             {
        if (valueObj == null) {
            return null;
        }
        if (valueObj instanceof java.util.Date) {
            long time = ((java.util.Date) valueObj).getTime();
            return new java.sql.Date(time);
        }
        try {
            java.sql.Date date = java.sql.Date.valueOf(valueObj.toString());
            return date;
        } catch (IllegalArgumentException iae) {
            log.debug("Errir on convert " + valueObj + " to Date");
            log.debug(iae.toString());
        }
        return null;
    }

    /**
     * 判断一个字符是否为英文字母
     * 
     * @param c
     *            要判断的字符
     * @return 如果字符为英文字母则返回true，否则返回false
     */
    public static boolean isEnLetter(char c) {
        return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
    }

    /**
     * 获取字符串中被引用的字符串 比如：strSource="$P{columnvalue}", startIndex=3, startChar="{"
     * endChar="}" 返回的字符串为：columnvalue
     * 
     * @param strSource
     *            用来检索引用字符串的方法
     * @param startIndex
     *            其实查找下标
     * @param startChar
     *            引用起始字符
     * @param endChar
     *            引用结束字符
     * @return
     */
    public static String getQuotedString(String strSource, int startIndex,
            char startChar, char endChar) {
        log.debug("sourceString:" + strSource + " startIndex:" + startIndex
                + " startChar:" + startChar + " endChar:" + endChar);
        int subLeftQuoter = 0;
        for (int i = startIndex; i < strSource.length(); i++) {
            char c = strSource.charAt(i);
            if (c == startChar) {
                subLeftQuoter++;
            } else if (c == endChar) {
                if (subLeftQuoter > 0) {
                    subLeftQuoter--;
                    continue;
                }
                return strSource.substring(startIndex, i);
            }
        }
        return null;
    }

    /**
     * 获取到quoteChar位置的字符串
     * 
     * @param strSource
     *            从其中检索字符串的源字符串
     * @param startIndex
     *            开始检索的位置
     * @param quoteChar
     *            引用字符
     * @return 子字符串
     */
    public static String getQuotedString(String strSource, int startIndex,
            char quoteChar) {
        log.debug("sourceString:" + strSource + " startIndex:" + startIndex
                + " quoteChar:" + quoteChar);
        for (int i = startIndex; i < strSource.length(); i++) {
            if (strSource.charAt(i) == quoteChar) {
                return strSource.substring(startIndex, i);
            }
        }
        return null;
    }

    /**
     * 生成指定时间的当天日期类型数据
     * 
     * @param strTime
     *            指定的时间
     * @return 当天的指定时间的日期对象
     */
    public static java.util.Date getTodayDate(String strTime) {
        strTime = strTime.trim();
        switch (strTime.split(":").length) {
        case 2: // 指定的时间数据包含了时和分的值, 在时间上添加秒的值
            strTime += ":00";
        case 3: // 指定的时间数据包含了时分秒的值
            // 在时间前面加上当天的日期
            strTime = ntsdf.format(new java.util.Date(System
                    .currentTimeMillis()))
                    + " " + strTime;
            log.debug("Time changed is:" + strTime);
            return parseDate(strTime);
        default:
            log.error("时间类型的数据格式不合法:" + strTime);
            return null;
        }
    }

    /**
     * 获取没有时间的日期字符串
     * 
     * @param date
     *            日期对象
     * @return 获取的yyyy-MM-dd格式的字符串
     */
    public static String getNoTimeDateString(java.util.Date date) {
        if (date == null) {
            return null;
        }
        try {
            return ntsdf.format(date);
        } catch (Exception ex) {
            return null;
        }
    }
}